﻿#define  _CRT_SECURE_NO_WARNINGS
#include <stdio.h>


//冒泡排序模拟 qsort
//
//int cmp_int(const void* p1, const void* p2)
//{
//	return *(int*)p1 - *(int*)p2;
//}
//
//void swap(char* p1, char* p2, int width)
//{
//	int i = 0;
//	for (i = 0; i < width; i++)
//	{
//		char tmp = *p1;
//		*p1 = *p2;
//		*p2 = tmp;
//		p1++;
//		p2++;
//	}
//}
//
//void bubble(void* base, size_t sz, size_t width, int (*p)(const void*, const void*))
//{
//	int i = 0;
//	int j = 0;
//	for (i = 0; i < sz - 1; i++)
//	{
//		for (j = 0; j < sz - 1 - i; j++)
//		{
//			if (p((char*)base + j * width, (char*)base + (j + 1) * width) > 0)
//			{
//				swap((char*)base + j * width, (char*)base + (j + 1) * width, width);
//			}
//		}
//	}
//}
//
//void test1()
//{
//	int arr[10] = { 5,3,6,8,7,2,1,4,10,9 };
//	int sz = sizeof(arr) / sizeof(arr[0]);
//	bubble(arr, sz, sizeof(arr[0]), cmp_int);
//	for (int i = 0; i < sz; i++)
//	{
//		printf("%d ", arr[i]);
//	}
//}
//
//int main()
//{
//	test1();
//
//	return 0;
//}



//int main()
//{
//	int a = 1;
//	int* p = &a;
//	*p = 20;
//	printf("%d\n", a);
//	printf("%d\n", *p);
//	return 0;
//}
//
//#include <stdio.h>
////指针变量的⼤⼩取决于地址的⼤⼩
////32位平台下地址是32个bit位（即4个字节）
////64位平台下地址是64个bit位（即8个字节）
//int main()
//{
//	printf("%zd\n", sizeof(char*));
//	printf("%zd\n", sizeof(short*));
//	printf("%zd\n", sizeof(int*));
//	printf("%zd\n", sizeof(double*));
//	return 0;
//}


//#include <stdio.h>
//int main()
//{
//	int n = 10;
//	char* pc = (char*)&n;
//	int* pi = &n;
//
//	printf("%p\n", &n);
//	printf("%p\n", pc);
//	printf("%p\n", pc + 1);
//	printf("%p\n", pi);
//	printf("%p\n", pi + 1);
//	return 0;
//}
//
//int main()
//{
//	int a = 10;
//	void* pa = &a;
//	
//	//*pa = 10;
//	*(int*)pa = 0;
//
//	printf("%d", a);
//
//	return 0;
//}


//int main()
//{
//	int a = 10;
//	int const* p1 = &a;
//	const int* p2 = &a;
//
//	*p1 = 20;
//	*p2 = 120;
//
//	p1 = 0x11111111111111;
//	p2 = 0x00111111111000;
//
//	return 0;
//}

//int main()
//{
//	int a = 10;
//	int* const p = &a;
//
//	*p = 20;
//	
//	p = 0x11111111111111;
//
//	return 0;
//}
//
//


//#include <stdio.h>
////指针+- 整数
//int main()
//{
//	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
//	//int* p = &arr[0];
//	char * p = &arr[0];
//	int i = 0;
//	int sz = sizeof(arr) / sizeof(arr[0]);
//	for (i = 0; i < sz; i++)
//	{
//		printf("%d ", *(p + i));//p+i 这⾥就是指针+整数
//	}
//	return 0;
//}


//#include <stdio.h>
//int my_strlen(char* s)
//{
//	char* p = s;
//	while (*p != '\0')
//		p++;
//	return p - s;
//}
//int main()
//{
//	printf("%d\n", my_strlen("abc"));
//	return 0;
//}

#include <stdio.h>
#include <assert.h>

//int main()
//{
//	int a = 10;
//	int* p1 = &a;
//	int* p2 = NULL;
//	assert(p2 != NULL);
//	return 0;
//}

//void Swap2(int* px, int* py)
//{
//	int tmp = 0;
//	tmp = *px;
//	*px = *py;
//	*py = tmp;
//}
//int main()
//{
//	int a = 0;
//	int b = 0;
//	scanf("%d %d", &a, &b);
//	printf("交换前：a=%d b=%d\n", a, b);
//	Swap2(&a, &b);
//	printf("交换后：a=%d b=%d\n", a, b);
//	return 0;
//}


//#include <stdio.h>
//int main()
//{
//	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
//	printf("&arr[0] = %p\n", &arr[0]);
//	printf("arr = %p\n", arr);
//	return 0;
//}

//int main()
//{
//	int arr[10] = { 1,2 };
//	printf("    arr  =%p\n", arr);
//	printf(" arr + 1 =%p\n", arr + 1);
//	printf("&arr + 1 =%p\n", &arr + 1);
//	return 0;
//}


//#include <stdio.h>
//void test(int arr[])
//{
//	int sz2 = sizeof(arr) / sizeof(arr[0]);
//	printf("sz2 = %d\n", sz2);
//}
//int main()
//{
//	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
//	int sz1 = sizeof(arr) / sizeof(arr[0]);
//	printf("sz1 = %d\n", sz1);
//	test(arr);
//	return 0;
//}

//int main()
//{
//	int a = 0;
//	int* p = &a;
//	int** pp = &p;
//	int*** ppp = &pp;
//
//
//
//	return 0;
//}

#include <stdio.h>
//int main()
//{
//	int arr1[] = { 1,2,3,4,5 };
//	int arr2[] = { 2,3,4,5,6 };
//	int arr3[] = { 3,4,5,6,7 };
//	//数组名是数组⾸元素的地址，类型是int*的，就可以存放在parr数组中
//	int* parr[3] = { arr1, arr2, arr3 };
//	int i = 0;
//	int j = 0;
//	for (i = 0; i < 3; i++)
//	{
//		for (j = 0; j < 5; j++)
//		{
//			printf("%d ", parr[i][j]);
//		}
//		printf("\n");
//	}
//	return 0;
//}



//int main()
//{
//	int arr[5] = { 1,2,3,4,5 };
//
//	printf("arr地址                 = %p\n", arr);
//	printf("首元素的地址            = %p\n", &arr[0]);
//	printf("首元素地址另一种表达方式= %p\n", arr + 0);
//
//	return 0;
//}


//int main()
//{
//	int arr[2][3] = { {0,1,2},{3,4,5} };
//
//	printf("二维数组数组名的地址       arr     = %p\n", arr);
//	printf("二维数组首行一维数组的地址 &arr[0] = %p\n", &arr[0]);
//
//	printf("\n");
//	//+1处理
//
//	printf("二维数组数组名的地址+1       arr+1     = %p\n", arr+1);
//	printf("二维数组首行一维数组的地址+1 &arr[0]+1 = %p\n", &arr[0]+1);
//
//	return 0;
//}					


//int main()
//{
//	int arr[3][4] = { {0,1,2},{3,4,5} };
//
//	int(*p)[4] = arr;
//
//	printf("arr[0]     =%p\n", arr[0]);
//	printf("&arr[0][0] =%p\n", &arr[0][0]);
//	printf("*p         =%p\n", *p);
//
//	printf("\n");
//	//+1处理后
//
//	printf("arr[0]+1       =%p\n", arr[0]+1);
//	printf("&(arr[0][0]+1) =%p\n", &arr[0][0]+1);
//	printf("*p+1           =%p\n", *p+1);
//
//
//	return 0;
//}

//int main()
//{
//	char s[20] = {0};
//	gets(s);
//
//	char (*p)[20] = s;
//
//	printf("%s\n", s);
//	printf("%s", p);
//	return 0;
//}
//
//int main()
//{
//	int arr[5] = { 0 };
//	int(*p)[5] = &arr;
//	return 0;
//}
//
//void print(int(*p)[3], int row, int col)
//{
//	int i = 0;
//	int j = 0;
//	for (i = 0; i < row; i++)
//	{
//		for (j = 0; j < col; j++)
//		{
//			printf("%d ", *(*(p + i) + j));
//		}
//		printf("\n")
//	}
//}
//
//int main()
//{
//	int arr[2][3] = { {1,2,3} ,{2,3,4} };
//	print(arr, 2, 3);
//	return 0;
//}

//void print(int* p,int sz)
//{
//	for (int i = 0; i < sz; i++)
//	{
//		printf("%d ", *(p + i));
//	}
//}
//
//int main()
//{
//	int arr[3] = { 1,2,3 };
//	print(arr, 3);
//	return 0;
//}

//void test()
//{
//	printf("hello world");
//}
//
//int main()
//{
//	void (*p1)(void) = test;
//	void (*p2)(void) = &test;
//
//	printf("%p\n", p1);
//	printf("%p\n", p2);
//}

//int add(int a, int b)
//{
//	return a + b;
//}
//
//int main()
//{
//	int (*p)(int, int) = add;
//	printf("%d\n", p(3, 4));
//	printf("%d\n", (*p)(3, 4));
//}

//typedef int(*fun)(int, int) ;
//
//int add(int a, int b)
//{
//	return a + b;
//}
//
//int main()
//{
//	fun p = add;
//	printf("%d\n", p(3, 4));
//	printf("%d\n", (*p)(3, 4));
//}



//void menu()
//{
//	printf("1、add	2、sub\n");
//	printf("3、mul	4、div\n");
//	printf("    0、exit   \n");
//}
//
//int add(int a, int b)
//{
//	return a + b;
//}
//
//int sub(int a, int b)
//{
//	return a - b;
//}
//
//int mul(int a, int b)
//{
//	return a * b;
//}
//
//int div(int a, int b)
//{
//	return a / b;
//}

//int main()
//{
//	int option = 0;
//	int i = 0;
//	int j = 0;
//	int (*cal[5])(int, int) = {0, add, sub, mul, div };
//	do
//	{
//		menu;
//		printf("选择计算方式\n");
//		scanf("%d", &option);
//		if (option == 0)
//		{
//			printf("退出\n");
//		}
//		else if (option > 0 && option <= 4)
//		{
//			printf("输入数据\n");
//			scanf("%d %d", &i, &j);
//			int ret = cal[option](i, j);
//			printf("%d\n", ret);
//		}
//		else
//		{
//			printf("请重新输入\n");
//		}
//	} while (option);
//	return 0;
//}

//void menu()
//{
//	printf("1、add	2、sub\n");
//	printf("3、mul	4、div\n");
//	printf("    0、exit   \n");
//}
//
//int add(int a, int b)
//{
//	return a + b;
//}
//
//int sub(int a, int b)
//{
//	return a - b;
//}
//
//int mul(int a, int b)
//{
//	return a * b;
//}
//
//int div(int a, int b)
//{
//	return a / b;
//}
//
//void cal(int (*p)(int, int))	//通过函数指针 p 来接收函数的地址
//{
//	int x = 0;
//	int y = 0;
//	printf("请输入两个数字\n");
//	scanf("%d %d", &x, &y);
//	int ret = p(x, y);			//通过 p 能够实现对该函数的调用
//	printf("%d\n", ret);
//}
//
//int main()
//{
//	int option = 0;
//	do
//	{
//		menu();
//		printf("选择计算方式\n");
//		scanf("%d", &option);
//		switch (option)
//		{
//		case 1:
//			cal(add);
//			break;
//		case 2:
//			cal(sub);
//			break;
//		case 3:
//			cal(mul);
//			break;
//		case 4:
//			cal(div);
//			break;
//		case 0:
//			printf("退出\n");
//			break;
//		default:
//			printf("重新输入\n");
//
//		}
//	} while (option);
//	return 0;
//}


//int int_cmp(const void* p1, const void* p2)
//{
//	return *(int*)p1 - *(int*)p2;
//}
//
//
//int main()
//{
//	int arr[10] = { 1,8,9,5,6,4,3,7,10,2 };
//	size_t sz = sizeof(arr) / sizeof(arr[0]);
//	qsort(arr, sz, sizeof(arr[0]), int_cmp);
//	for (int i = 0; i < sz; i++)
//	{
//		printf("%d ", arr[i]);
//	}
//	return 0;
//}

//struct stu
//{
//	char name[20];
//	int age;
//};

//int int_cmp(const void* p1, const void* p2)
//{
//	return ((struct stu*)p1)->age - ((struct stu*)p2)->age;
//}
//
//int main()
//{
//	struct stu s[3] = {{"zhangsan",20},{"lisi",19},{"wangwu",16}};
//	size_t sz = sizeof(s) / sizeof(s[0]);
//	qsort(s, sz, sizeof(s[0]), int_cmp);
//	return 0;
//}

#include <string.h>

//int char_cmp(const void* p1, const void* p2)
//{
//	return strcmp(((struct stu*)p1)->name, ((struct stu*)p2)->name);
//}
//
//int main()
//{
//	struct stu s[3] = { {"zhangsan",20},{"lisi",19},{"wangwu",16} };
//	size_t sz = sizeof(s) / sizeof(s[0]);
//	qsort(s, sz, sizeof(s[0]), char_cmp);
//	return 0;
//}

//int int_cmp(const void* p1, const void* p2)
//{
//	return *(char*)p1 - *(char*)p2;
//}
//
//void swap(const void* p1, const void* p2,size_t width)
//{
//	int i = 0;
//	char tmp = 0;
//	for (i = 0; i < width; i++)
//	{
//		tmp = *((char*)p1 + i);
//		*((char*)p1 + i) = *((char*)p2 + i);
//		*((char*)p2 + i) = tmp;
//	}
//}
//
//void bubble(const void* base, size_t sz, size_t width, int (*cmp)(const void*, const void*))
//{
//	int i = 0;
//	int j = 0;
//	int tmp = 0;
//	for (i; i < sz - 1; i++)
//	{
//		for (j = 0; j < sz - i - 1; j++)
//		{
//			if (cmp((char*)base + j * width, (char*)base + (j + 1) * width) > 0)
//			{
//				swap((char*)base + j * width, (char*)base + (j + 1) * width,width);
//			}
//		}
//	}
//}
//
//int main()
//{
//	int arr[10] = { 1,8,9,5,6,4,3,7,10,2 };
//	size_t sz = sizeof(arr) / sizeof(arr[0]);
//	
//	bubble(arr, sizeof(arr) / sizeof(arr[0]), sizeof(arr[0]), int_cmp);
//
//	for (int i = 0; i < sz; i++)
//	{
//		printf("%d ", arr[i]);
//	}
//
//	return 0;
//}

//
//int main()
//{
//	printf("%zd", sizeof(int(*)[4]));
//	return 0;
//}


//void GetMemory(char** p)
//{
//	p = (char*)malloc(100);
//}
//void Test(void)
//{
//	char* str = NULL;
//	GetMemory(&str);
//	strcpy(str, "hello world");
//	printf(str);
//}
//
//int main()
//{
//	Test();
//	return 0;
//}

#include <ctype.h>

//int main()
//{
//	char str[] = "    abcd     ";
//	int count = 0;
//	int i = 0;
//	while (isspace(str[i]))
//	{
//		count++;
//		i++;
//	}
//
//	printf("%d", count);
//
//	return 0;
//}


//#include <ctype.h>
//
//int main()
//{
//	char str[] = "123dad312f";
//	int i = 0;
//
//	while (str[i] != '\0')
//	{
//		if (isdigit(str[i]))
//		{
//			while (isdigit(str[i]))
//			{
//				printf("%c", str[i]);
//				i++;
//			}
//		}
//		else
//		{
//			i++;
//		}
//	}
//	return 0;
//}


//#include <ctype.h>
//
//int main()
//{
//	char str[] = "123da6578ASDd3dc12fADSC";
//	int i = 0;
//
//	while (str[i] != '\0')
//	{
//		if (isalpha(str[i]))
//		{
//			while (isalpha(str[i]))
//			{
//				printf("%c", str[i]);
//				i++;
//			}
//		}
//		else
//		{
//			i++;
//		}
//	}
//	return 0;
//}


//#include <ctype.h>
//
//int main()
//{
//	char str[] = "123dad312f";
//	int i = 0;
//	char c = 0;
//
//	while (str[i] != '\0')
//	{
//		if (islower(str[i]))
//		{
//			
//			while (islower(str[i]))
//			{
//				str[i] = toupper(str[i]);
//				i++;
//			}
//		}
//		else
//		{
//			i++;
//		}
//	}
//	printf("%s", str);
//	return 0;
//}

//#include <ctype.h>
//
//int main()
//{
//	char str[] = "123CEDdad3ASD12f";
//	int i = 0;
//	char c = 0;
//
//	while (str[i] != '\0')
//	{
//		if (isupper(str[i]))
//		{
//
//			while (isupper(str[i]))
//			{
//				str[i] = tolower(str[i]);
//				i++;
//			}
//		}
//		else
//		{
//			i++;
//		}
//	}
//	printf("%s", str);
//	return 0;
//}


#include <string.h>

//int main()
//{
//	char* str = "hello bit";
//	char str1[20] = { 0 };
//	strcpy(str1, str);
//	printf("%s", str1);
//
//	return 0;
//}

#include <assert.h>

//char* my_strlen(char* p1, const char* p2)
//{
//	assert(p1 && p2);
//	char* cur = p1;
//	while (*p2 != '\0')
//	{
//		*p1++ = *p2++;
//	}
//	return cur;
//}
//
//int main()
//{
//	char* s1 = "hello bit";
//	char s2[20] = { 0 };
//	char* ret = my_strlen(s2, s1);
//
//	printf("%s", ret);
//
//	return 0;
//}

#include <string.h>

//int main()
//{
//	char* s1 = "hello";
//	char* s2 = " bit";
//
//	strcat(s1, s2);
//
//
//	printf("%s", s1);
//
//	return 0;
//}

//int main()
//{
//	char* s1 = "abcdasd";
//	char* s2 = "abcf";
//	int ret = 0;
//	ret = strcmp(s1, s2);
//	printf("%d",ret);
//	return 0;
//}

//int main()
//{
//	char* s1 = "hello";
//	char s2[20] = { 0 };
//
//	strncpy(s2, s1, 3);
//	printf("%s", s2);
//}


//int main()
//{
//	char* s = "i am a student 233";
//	char s1[20] = { 0 };
//	
//	char* cur = NULL;
//	cur = strstr(s, "student");
//	if (cur == 0)
//	{
//		return 1;
//	}
//	strncpy(s1, cur, 7);
//	printf("%s", s1);
//
//	return 0;
//}

#include <string.h>
#include <assert.h>

//int main()
//{
//	char s1[20] = "hello bit";
//	char s2[20] = { 0 };
//
//	memcpy(s2, s1,5);
//	memmove(s1, s1 + 2, 5);
//	
//	printf("%s\n", s2);
//	printf("%s", s1);
//
//	return 0;
//}

//void* my_memcpy(void* p2, const void* p1, size_t n)
//{
//	assert(p1 && p2);
//	
//	while (n)
//	{
//		*((int*)p2) = *((int*)p1);
//		p1 = (int*)p1 + 1;
//		p2 = (int*)p2 + 1;
//		n--;
//	}
//}
//
//int main()
//{
//	int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };
//	int arr2[20] = { 0 };
//
//	my_memcpy(arr2, arr1, 5);
//	for (int i = 0; i < 5; i++)
//	{
//		printf("%d ", arr2[i]);
//	}
//	return 0;
//}


//int main()
//{
//	int arr1[20] = { 1,2,3,4,5,6,7,8,9,10 };
//	memmove(arr1, arr1 + 2, 5);
//	for (int i = 0; i < 10; i++)
//	{
//		printf("%d ", arr1[i]);
//	}
//	return 0;
//}

//int main()
//{
//	int a = 0x11223344;
//	
//	return 0;
//}


//#include <stdio.h>
//int main()
//{
//	char a = -1;
//	//	-1的原码：10000000/00000000/00000000/00000001
//	//	-1的反码：11111111/11111111/11111111/11111110
//	//  -1的补码：11111111/11111111/11111111/11111111
//	//	因为 a是 char类型的变量，所以只取低八位得	11111111，其中最高位是符号位；
//	//	但是 a最终以%d形式打印，因此会整型提升，而a是有符号的 a所以最高位按符号位提升得
//	//	补码：11111111/11111111/11111111/11111111
//	//	反码：10000000/00000000/00000000/00000000
//	//	原码：10000000/00000000/00000000/00000001
//	//	打印：-1
//	signed char b = -1;
//	//	b与a同理
//	unsigned char c = -1;
//	//	前三步与a同理，最后得到 11111111，其中最高位1不是符号位
//	//	因为 c是无符号数（正数），所以在整型提升时，最高位补0
//	//	得    00000000/00000000/00000000/11111111	正数得原反补相同，所以。
//	//	补码：00000000/00000000/00000000/11111111
//	//	反码：00000000/00000000/00000000/11111111
//	//	补码：00000000/00000000/00000000/11111111
//	//	打印：255
//	printf("a=%d,b=%d,c=%d", a, b, c);
//	return 0;
//}


//#include <stdio.h>
//int main()
//{
//	char a = -128;
//	//	-128的原码：10000000/00000000/00000000/10000000
//	//	-128的反码：11111111/11111111/11111111/01111111
//	//	-128的补码：11111111/11111111/11111111/10000000
//	//	a为有符号的 char类型的数据，只取低八位，最高位为符号位
//	//	100000000
//	//	因为a是有符号的 char类型，所以整型提升最高位按符号位提升得
//	//	补码：11111111/11111111/11111111/10000000
//	//	最终以 %u 的形式打印，属于无符号打印，因此最终最高位的1不再代表符号位，此时补码为正，原反补相同
//	//	答：4,294,967,168
//	printf("%u\n", a);
//	return 0;
//}


//#include <stdio.h>
//int main()
//{
//	char a = 128;
//	//	128的原码：00000000/00000000/00000000/10000000
//	//	128的反码：00000000/00000000/00000000/10000000
//	//	128的补码：00000000/00000000/00000000/10000000
//	//	a为有符号的 char类型的数据，只取低八位，最高位为符号位
//	//	10000000
//	//	因为a是有符号的 char类型，所以整型提升最高位按符号位提升得
//	//	补码：11111111/11111111/11111111/10000000
//	printf("%u\n", a);
//	return 0;
//}


//#include <stdio.h>
//int main()
//{
//	char a[1000];//有符号的char类型的取值范围为-128~127
//	int i;
//	for (i = 0; i < 1000; i++)
//	{
//		a[i] = -1 - i;
//		//当i为 -129时
//		//	-129的原码为：10000000/00000000/00000000/10000001；
//		//	-129的反码为：11111111/11111111/11111111/01111110；
//		//	-129的补码为：11111111/11111111/11111111/01111111；
//		//	因为a是有符号的char类型的变量，所以只取低八位，且最高位是符号位
//		//	补码：01111111 将该补码(为正数)赋值给a[i] 
//		//	反码：01111111
//		//	补码：01111111 → 127
//		//	即  i 会从-128 变为 127，重新开始减1 直至0 
//	}
//	printf("%d", strlen(a));
//	return 0;
//}
//
//
//#include <stdio.h>
//int main()
//{
//	int a[4] = { 1, 2, 3, 4 };
//	int* ptr1 = (int*)(&a + 1);	
//	//	a 是数组，&a 的指针变量类型为 int(*)[4] 所以要将其强转为 int* 型
//	//	取地址a 得到的是一整个数组的地址，+1会跳过一整个数组
//	//	此时 ptr指向元素4跳过4个字节的起始位置处
//	int* ptr2 = (int*)((int)a + 1);
//	//	a是数组名，数组名为首元素地址，把地址强转为 int型变量，+1 地址大小+1，再强转为 int* 类型的指针 此时 ptr2指向第一个元素的第二个字节处
//	//	注：int型 一个元素占四个字节
//	printf("%x,%x", ptr1[-1], *ptr2);//4 因 ptr2为 int型类型的指针，解引用会向后访问四个字节 2000000
//	return 0;
//}


//#include <stdio.h>
//int main()
//{
//	int n = 9;
//	float* pFloat = (float*)&n;
//	printf("n的值为：%d\n", n);
//	printf("*pFloat的值为：%f\n", *pFloat);
//	//9的补码为
//	//0/00000000/00000000000000000001001
//	//如果以%f打印，则E全为0 减去127后 得-127 相当于1.00000000000000000001001*2^(-127) 是一个相当小得数，几乎为0
//
//	*pFloat = 9.0;
//	printf("num的值为：%d\n", n);
//
//	//数字9的二进制为 1001
//	//如果以浮点型数据进行存储，
//	//那么 E = 3+127 其二进制表示为 1000 0010
//	//M舍去1 得001
//	//正数则 S = 0；
//	//最终的浮点数在内存中存储的二进制补码为：0/10000000/ 001 /00000000/00000000/00000000 如果以%d打印将会是一个非常大的数
//
//	printf("*pFloat的值为：%f\n", *pFloat);
//	return 0;
//}

//struct stu
//{
//	char name[20];
//	char sex;
//	int age;
//	float weight;
//	float height;
//};
//
//int main()
//{
//	struct stu s = { {"jc"},{"male"},{18},{78.8},{178.8} };
//
//	struct stu* p = &s;
//
//	printf("%s\n", s.name);		//结构体成员直接访问操作符
//	printf("%s\n", p->name);	//结构体成员间接访问操作符
//
//	return 0;
//}


//struct S1		//假设结构体的起始地址为：0
//{	
//	char c1;	//
//	int i;		//
//	char c2;	//
//};
//int main()
//{
//	printf("%d\n", sizeof(struct S1));
//}


//struct S3
//{
//	double d;
//	char c;
//	int i;
//};
//
//struct S4
//{
//	char c1;
//	struct S3 s3;
//	double d;
//};
//
//int main()
//{
//	printf("%d", sizeof(struct S4));
//	printf("%d\n", sizeof(struct S3));
//	return 0;
//}


//struct S3
//{
//	double d;
//	char c;
//	int i;
//};
//
//void print(struct S3* p)
//{
//	printf("%f\n", p->d);
//	printf("%c\n", p->c);
//	printf("%d\n", p->i);
//}
//
//int main()
//{
//	struct S3 s = { {88.8},{'a'},{23} };
//	print(&s);
//	return 0;
//}

//struct S
//{
//	char a : 3;
//	char b : 4;
//	char c : 5;
//	char d : 4;
//};
//
//int main()
//{
//	struct S s = { 0 };
//	s.a = 10;
//	s.b = 12;
//	s.c = 3;
//	s.d = 4;
//
//	return 0;
//}


//enum s1
//{
//	a,
//	b,
//	d
//};
//
//union s
//{
//	int a;
//	char b;
//};

//union Un2
//{
//	short c[7];
//	int i;
//};
//int main()
//{
//	printf("%d\n", sizeof(union Un2));
//	return 0;
//}

//enum s
//{
//	a,
//	b,
//	c = 233,
//	d,
//	e
//};
//
//int main()
//{
//	enum s n0 = a;
//	enum s n1 = b;
//	enum s n2 = c;
//	enum s n3 = d;
//	enum s n4 = e;
//
//	printf("%d %d %d %d %d ", a,b,c,d,e);
//	return 0;
//}

#include <stdlib.h>

//int main()
//{
//	int* p = NULL;
//	p = (int*)malloc(10 * sizeof(int));// malloc的返回值是 void* 指针，根据需求需要进行强制类型转换
//	if (p == NULL)
//	{
//		return 1;
//	}
//
//	for (int i = 0; i < 10; i++)
//	{
//		*(p + i) = i + 1;
//	}
//
//	for (int i = 0; i < 10; i++)
//	{
//		printf("%d ", *(p + i));
//	}
//
//	free(p);	//动态内存使用完需要释放
//	p = NULL;	//并且将指针置为NULL，否则该指针就是野指针，指向的内存区域非法。
//
//	return 0;
//}


//int main()
//{
//	int* p1 = NULL;
//	int* p2 = NULL;
//
//	p1 = (int*)malloc(10 * sizeof(int));
//	p2 = (int*)calloc(10, sizeof(int));
//
//	return 0;
//}

//int main()
//{
//	int* p = (int*)malloc(10 * sizeof(int));
//
//	if (p == NULL)
//	{
//		return 1;
//	}
//
//	int* p1 = realloc(p, 20 * sizeof(int));
//
//	if (p1 == NULL)
//	{
//		return 1;
//	}
//
//	p = p1;
//
//	free(p1);
//	p1 = NULL;
//	free(p);
//	p = NULL;
//
//	return 0;
//}

								
//void GetMemory(char* p)			//	形参 p 用来接收实参 str，此时内存会临时开辟一块内存空间来存放p，假设此时指针 p的地址为b
//{								//	
//	p = (char*)malloc(100);		//	malloc 开辟一块动态区域，并将该空间的起始地址返回给 p，地址b所对应的形参p中的值发生变化，	
//}								//	但是地址a 对应的实参str没有发生任何改变，因此str仍为空指针
//void Test(void)					//
//{								//	
//	char* str = NULL;			//
//	GetMemory(str);				//	将指针 str作为实参传递给自定义函数，假设此时指针 str 的地址为a
//	strcpy(str, "hello world");	//
//	printf(str);				//
//}


#include <stdlib.h>

//char* GetMemory()
//{
//	return (char*)malloc(100);
//
//}
//void Test(void)
//{
//	char* str = NULL;
//	str = GetMemory();
//	strcpy(str, "hello world");
//	printf(str);
//	free(str);
//	str = NULL;
//}
//
//int main()
//{
//	Test();
//	return 0;
//}

								
//void* GetMemory(char** p)		//	用二级指针 p 作为形参来接收实参 str，则p中存放的是 str的地址 a
//{								//
//	*p = (char*)malloc(100);	//	对p解引用，访问的是 str的内容，将 malloc函数的返回值传递给 *p，是直接改变 str中的值，
//}								//
//void Test(void)					//
//{								//
//	char* str = NULL;			//
//	 GetMemory(&str);			//	将 str的地址作为实参传递到自定义函数中，假设此时 str的地址为 a
//	strcpy(str, "hello world");	//
//	printf(str);
//	free(str);
//	str = NULL;
//}
//
//int main()
//{
//	Test();
//
//	return 0;
//}

//
//char* GetMemory(void)
//{
//	char p[] = "hello world";
//	return p;
//}
//void Test(void)
//{
//	char* str = NULL;
//	str = GetMemory();
//	printf(str);
//}
//
//int main()
//{
//	Test();
//
//	return 0;
//}

//int main()
//{
//	FILE* p = fopen("data.txt", "w");
//	if (p == NULL)
//	{
//		perror("");
//		return 1;
//	}
//
//	fclose(p);
//	p = NULL;
//
//	return 0;
//}

int main()
{											//	文件写入
	FILE* p1 = fopen("test.txt", "w");		//	创建文件 test.txt  
	if (p1 == NULL)							//	确认是否成功创建
	{										//
		perror("");							//
		return 1;							//
	}										//
	int i = 0;								//
	for (i = 'a'; i <= 'z'; i++)			//	循环写入26个英文字母
	{										//
		fputc(i, p1);						//
	}										//
	fclose(p1);								//	关闭文件
	p1 = NULL;								//	指针置为空，避免野指针
											//
	FILE* p2 = fopen("test.txt", "r");		//	读取刚刚写入的内容
	int n = 0;								//	
	while ((n = fgetc(p2)) != EOF)			//	因为 fgetc的返回类型时 int，所以需要创建一个 int类型的变量来接受
	{										//	其次，读取成功与否返回的都是 EOF，所以用 读取内容 =EOF来判断
		printf("%c ", n);					//
	}										//
											//
	fclose(p2);								//	关闭文件
	p2 = NULL;								//	指针置为空，避免野指针
											//
	return 0;								//
}